home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / preloaders / DownloadProgressBar.as next >
Encoding:
Text File  |  2008-05-21  |  25.7 KB  |  799 lines
  1. package mx.preloaders
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.GradientType;
  5.    import flash.display.Graphics;
  6.    import flash.display.Loader;
  7.    import flash.display.LoaderInfo;
  8.    import flash.display.Sprite;
  9.    import flash.events.Event;
  10.    import flash.events.IOErrorEvent;
  11.    import flash.events.ProgressEvent;
  12.    import flash.events.TimerEvent;
  13.    import flash.geom.Matrix;
  14.    import flash.geom.Rectangle;
  15.    import flash.net.URLRequest;
  16.    import flash.system.ApplicationDomain;
  17.    import flash.system.LoaderContext;
  18.    import flash.text.TextField;
  19.    import flash.text.TextFormat;
  20.    import flash.utils.Timer;
  21.    import flash.utils.getDefinitionByName;
  22.    import flash.utils.getTimer;
  23.    import mx.core.mx_internal;
  24.    import mx.events.FlexEvent;
  25.    import mx.events.RSLEvent;
  26.    import mx.graphics.RectangularDropShadow;
  27.    import mx.graphics.RoundedRectangle;
  28.    
  29.    use namespace mx_internal;
  30.    
  31.    public class DownloadProgressBar extends Sprite implements IPreloaderDisplay
  32.    {
  33.       mx_internal static const VERSION:String = "2.0.1.0";
  34.       
  35.       private static var _initializingLabel:String = "Initializing";
  36.       
  37.       private var _stageHeight:Number = 375;
  38.       
  39.       private var _percentRect:Rectangle;
  40.       
  41.       private var _percentObj:TextField;
  42.       
  43.       private var _backgroundSize:String = "";
  44.       
  45.       private var _showLabel:Boolean = true;
  46.       
  47.       private var _value:Number = 0;
  48.       
  49.       private var _backgroundAlpha:Number = 1;
  50.       
  51.       private var _backgroundImage:Object;
  52.       
  53.       private var _backgroundColor:uint;
  54.       
  55.       protected var DOWNLOAD_PERCENTAGE:uint = 60;
  56.       
  57.       private var _labelObj:TextField;
  58.       
  59.       private var _barFrameSprite:Sprite;
  60.       
  61.       private var _maximum:Number = 0;
  62.       
  63.       private var _startTime:int;
  64.       
  65.       private var _preloader:Sprite;
  66.       
  67.       private var _displayTime:int;
  68.       
  69.       protected var MINIMUM_DISPLAY_TIME:uint = 0;
  70.       
  71.       private var _stageWidth:Number = 500;
  72.       
  73.       private var _downloadingLabel:String = "Loading";
  74.       
  75.       private var _showProgressBar:Boolean = true;
  76.       
  77.       private var _yOffset:Number = 20;
  78.       
  79.       private var _initProgressCount:uint = 0;
  80.       
  81.       private var _barSprite:Sprite;
  82.       
  83.       private var _visible:Boolean = false;
  84.       
  85.       private var _barRect:RoundedRectangle;
  86.       
  87.       private var _showingDisplay:Boolean = false;
  88.       
  89.       private var _initProgressTotal:uint = 12;
  90.       
  91.       private var _startedInit:Boolean = false;
  92.       
  93.       private var _labelRect:Rectangle;
  94.       
  95.       private var _showPercentage:Boolean = false;
  96.       
  97.       private var _startedLoading:Boolean = false;
  98.       
  99.       private var _displayStartCount:uint = 0;
  100.       
  101.       private var _borderRect:RoundedRectangle;
  102.       
  103.       private var _xOffset:Number = 20;
  104.       
  105.       private var _label:String = "";
  106.       
  107.       private var _barFrameRect:RoundedRectangle;
  108.       
  109.       public function DownloadProgressBar()
  110.       {
  111.          MINIMUM_DISPLAY_TIME = 0;
  112.          DOWNLOAD_PERCENTAGE = 60;
  113.          _showProgressBar = true;
  114.          _labelRect = labelRect;
  115.          _percentRect = percentRect;
  116.          _borderRect = borderRect;
  117.          _barFrameRect = barFrameRect;
  118.          _barRect = barRect;
  119.          _xOffset = 20;
  120.          _yOffset = 20;
  121.          _maximum = 0;
  122.          _value = 0;
  123.          _startedLoading = false;
  124.          _startedInit = false;
  125.          _showingDisplay = false;
  126.          _displayStartCount = 0;
  127.          _initProgressCount = 0;
  128.          _initProgressTotal = 12;
  129.          _visible = false;
  130.          _backgroundAlpha = 1;
  131.          _backgroundSize = "";
  132.          _stageHeight = 375;
  133.          _stageWidth = 500;
  134.          _downloadingLabel = "Loading";
  135.          _label = "";
  136.          _showLabel = true;
  137.          _showPercentage = false;
  138.          super();
  139.       }
  140.       
  141.       public static function get initializingLabel() : String
  142.       {
  143.          return _initializingLabel;
  144.       }
  145.       
  146.       public static function set initializingLabel(param1:String) : void
  147.       {
  148.          _initializingLabel = param1;
  149.       }
  150.       
  151.       private function calcScale() : void
  152.       {
  153.          var _loc1_:Number = NaN;
  154.          if(stageWidth < 160 || stageHeight < 120)
  155.          {
  156.             scaleX = 1;
  157.             scaleY = 1;
  158.          }
  159.          else if(stageWidth < 240 || stageHeight < 150)
  160.          {
  161.             createChildren();
  162.             _loc1_ = Math.min(stageWidth / 240,stageHeight / 150);
  163.             scaleX = _loc1_;
  164.             scaleY = _loc1_;
  165.          }
  166.          else
  167.          {
  168.             createChildren();
  169.          }
  170.       }
  171.       
  172.       protected function get labelFormat() : TextFormat
  173.       {
  174.          var _loc1_:TextFormat = null;
  175.          _loc1_ = new TextFormat();
  176.          _loc1_.color = 3355443;
  177.          _loc1_.font = "Verdana";
  178.          _loc1_.size = 10;
  179.          return _loc1_;
  180.       }
  181.       
  182.       protected function rslCompleteHandler(param1:RSLEvent) : void
  183.       {
  184.          label = "Loaded library " + param1.rslIndex + " of " + param1.rslTotal;
  185.       }
  186.       
  187.       protected function set showLabel(param1:Boolean) : void
  188.       {
  189.          _showLabel = param1;
  190.          draw();
  191.       }
  192.       
  193.       private function calcBackgroundSize() : Number
  194.       {
  195.          var _loc1_:Number = NaN;
  196.          var _loc2_:int = 0;
  197.          _loc1_ = NaN;
  198.          if(backgroundSize)
  199.          {
  200.             _loc2_ = int(backgroundSize.indexOf("%"));
  201.             if(_loc2_ != -1)
  202.             {
  203.                _loc1_ = Number(backgroundSize.substr(0,_loc2_));
  204.             }
  205.          }
  206.          return _loc1_;
  207.       }
  208.       
  209.       protected function rslErrorHandler(param1:RSLEvent) : void
  210.       {
  211.          _preloader.removeEventListener(ProgressEvent.PROGRESS,progressHandler);
  212.          _preloader.removeEventListener(Event.COMPLETE,completeHandler);
  213.          _preloader.removeEventListener(RSLEvent.RSL_PROGRESS,rslProgressHandler);
  214.          _preloader.removeEventListener(RSLEvent.RSL_COMPLETE,rslCompleteHandler);
  215.          _preloader.removeEventListener(RSLEvent.RSL_ERROR,rslErrorHandler);
  216.          _preloader.removeEventListener(FlexEvent.INIT_PROGRESS,initProgressHandler);
  217.          _preloader.removeEventListener(FlexEvent.INIT_COMPLETE,initCompleteHandler);
  218.          if(!_showingDisplay)
  219.          {
  220.             show();
  221.             _showingDisplay = true;
  222.          }
  223.          label = "RSL Error " + (param1.rslIndex + 1) + " of " + param1.rslTotal;
  224.       }
  225.       
  226.       protected function get barFrameRect() : RoundedRectangle
  227.       {
  228.          return new RoundedRectangle(14,40,154,4);
  229.       }
  230.       
  231.       private function loader_ioErrorHandler(param1:IOErrorEvent) : void
  232.       {
  233.       }
  234.       
  235.       protected function get borderRect() : RoundedRectangle
  236.       {
  237.          return new RoundedRectangle(0,0,182,60,4);
  238.       }
  239.       
  240.       protected function showDisplayForDownloading(param1:int, param2:ProgressEvent) : Boolean
  241.       {
  242.          return param1 > 700 && param2.bytesLoaded < param2.bytesTotal / 2;
  243.       }
  244.       
  245.       private function timerHandler(param1:Event = null) : void
  246.       {
  247.          dispatchEvent(new Event(Event.COMPLETE));
  248.       }
  249.       
  250.       protected function progressHandler(param1:ProgressEvent) : void
  251.       {
  252.          var _loc2_:uint = 0;
  253.          var _loc3_:uint = 0;
  254.          var _loc4_:int = 0;
  255.          _loc2_ = param1.bytesLoaded;
  256.          _loc3_ = param1.bytesTotal;
  257.          _loc4_ = getTimer() - _startTime;
  258.          if(_showingDisplay || showDisplayForDownloading(_loc4_,param1))
  259.          {
  260.             if(!_startedLoading)
  261.             {
  262.                show();
  263.                label = downloadingLabel;
  264.                _startedLoading = true;
  265.             }
  266.             setProgress(param1.bytesLoaded,param1.bytesTotal);
  267.          }
  268.       }
  269.       
  270.       public function get backgroundSize() : String
  271.       {
  272.          return _backgroundSize;
  273.       }
  274.       
  275.       override public function get visible() : Boolean
  276.       {
  277.          return _visible;
  278.       }
  279.       
  280.       protected function center(param1:Number, param2:Number) : void
  281.       {
  282.          _xOffset = Math.floor((param1 - _borderRect.width) / 2);
  283.          _yOffset = Math.floor((param2 - _borderRect.height) / 2);
  284.       }
  285.       
  286.       protected function get barRect() : RoundedRectangle
  287.       {
  288.          return new RoundedRectangle(14,39,154,6,0);
  289.       }
  290.       
  291.       protected function rslProgressHandler(param1:RSLEvent) : void
  292.       {
  293.       }
  294.       
  295.       public function set backgroundSize(param1:String) : void
  296.       {
  297.          _backgroundSize = param1;
  298.       }
  299.       
  300.       private function initCompleteHandler(param1:Event) : void
  301.       {
  302.          var _loc2_:int = 0;
  303.          var _loc3_:Timer = null;
  304.          _loc2_ = getTimer() - _displayTime;
  305.          if(_showingDisplay && _loc2_ < MINIMUM_DISPLAY_TIME)
  306.          {
  307.             _loc3_ = new Timer(MINIMUM_DISPLAY_TIME - _loc2_,1);
  308.             _loc3_.addEventListener(TimerEvent.TIMER,timerHandler);
  309.             _loc3_.start();
  310.          }
  311.          else
  312.          {
  313.             timerHandler();
  314.          }
  315.       }
  316.       
  317.       protected function get percentFormat() : TextFormat
  318.       {
  319.          var _loc1_:TextFormat = null;
  320.          _loc1_ = new TextFormat();
  321.          _loc1_.align = "right";
  322.          _loc1_.color = 0;
  323.          _loc1_.font = "Verdana";
  324.          _loc1_.size = 10;
  325.          return _loc1_;
  326.       }
  327.       
  328.       private function calcY(param1:Number) : Number
  329.       {
  330.          return param1 + _yOffset;
  331.       }
  332.       
  333.       protected function setProgress(param1:Number, param2:Number) : void
  334.       {
  335.          if(!isNaN(param1) && !isNaN(param2) && param1 >= 0 && param2 > 0)
  336.          {
  337.             _value = Number(param1);
  338.             _maximum = Number(param2);
  339.             draw();
  340.          }
  341.       }
  342.       
  343.       protected function get downloadingLabel() : String
  344.       {
  345.          return _downloadingLabel;
  346.       }
  347.       
  348.       private function calcX(param1:Number) : Number
  349.       {
  350.          return param1 + _xOffset;
  351.       }
  352.       
  353.       protected function showDisplayForInit(param1:int, param2:int) : Boolean
  354.       {
  355.          return param1 > 300 && param2 == 2;
  356.       }
  357.       
  358.       private function drawProgressBar(param1:Number) : void
  359.       {
  360.          var _loc2_:Graphics = null;
  361.          var _loc3_:Array = null;
  362.          var _loc4_:Array = null;
  363.          var _loc5_:Matrix = null;
  364.          var _loc6_:Number = NaN;
  365.          var _loc7_:Number = NaN;
  366.          var _loc8_:Number = NaN;
  367.          var _loc9_:Number = NaN;
  368.          var _loc10_:Number = NaN;
  369.          var _loc11_:Number = NaN;
  370.          _loc2_ = _barSprite.graphics;
  371.          _loc2_.clear();
  372.          _loc3_ = [16777215,16777215];
  373.          _loc4_ = [0,255];
  374.          _loc5_ = new Matrix();
  375.          _loc6_ = _barRect.width * param1 / 100;
  376.          _loc7_ = _loc6_ / 2;
  377.          _loc8_ = _barRect.height - 4;
  378.          _loc9_ = calcX(_barRect.x);
  379.          _loc10_ = calcY(_barRect.y) + 2;
  380.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  381.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.39,0.85],_loc4_,_loc5_);
  382.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,_loc8_);
  383.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  384.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.85,1],_loc4_,_loc5_);
  385.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,_loc8_);
  386.          _loc7_ = _loc6_ / 3;
  387.          _loc8_ = _barRect.height;
  388.          _loc10_ = calcY(_barRect.y);
  389.          _loc11_ = _loc10_ + _loc8_ - 1;
  390.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  391.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.05,0.15],_loc4_,_loc5_);
  392.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,1);
  393.          _loc2_.drawRect(_loc9_,_loc11_,_loc7_,1);
  394.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  395.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.15,0.25],_loc4_,_loc5_);
  396.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,1);
  397.          _loc2_.drawRect(_loc9_ + _loc7_,_loc11_,_loc7_,1);
  398.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_ * 2,_loc10_);
  399.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.25,0.1],_loc4_,_loc5_);
  400.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc10_,_loc7_,1);
  401.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc11_,_loc7_,1);
  402.          _loc7_ = _loc6_ / 3;
  403.          _loc8_ = _barRect.height;
  404.          _loc10_ = calcY(_barRect.y) + 1;
  405.          _loc11_ = calcY(_barRect.y) + _loc8_ - 2;
  406.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_,_loc10_);
  407.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.15,0.3],_loc4_,_loc5_);
  408.          _loc2_.drawRect(_loc9_,_loc10_,_loc7_,1);
  409.          _loc2_.drawRect(_loc9_,_loc11_,_loc7_,1);
  410.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_,_loc10_);
  411.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.3,0.4],_loc4_,_loc5_);
  412.          _loc2_.drawRect(_loc9_ + _loc7_,_loc10_,_loc7_,1);
  413.          _loc2_.drawRect(_loc9_ + _loc7_,_loc11_,_loc7_,1);
  414.          _loc5_.createGradientBox(_loc7_,_loc8_,0,_loc9_ + _loc7_ * 2,_loc10_);
  415.          _loc2_.beginGradientFill(GradientType.LINEAR,_loc3_,[0.4,0.25],_loc4_,_loc5_);
  416.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc10_,_loc7_,1);
  417.          _loc2_.drawRect(_loc9_ + _loc7_ * 2,_loc11_,_loc7_,1);
  418.       }
  419.       
  420.       public function get backgroundImage() : Object
  421.       {
  422.          return _backgroundImage;
  423.       }
  424.       
  425.       public function set stageWidth(param1:Number) : void
  426.       {
  427.          _stageWidth = param1;
  428.       }
  429.       
  430.       public function get backgroundAlpha() : Number
  431.       {
  432.          if(!isNaN(_backgroundAlpha))
  433.          {
  434.             return _backgroundAlpha;
  435.          }
  436.          return 1;
  437.       }
  438.       
  439.       public function set preloader(param1:Sprite) : void
  440.       {
  441.          _preloader = param1;
  442.          param1.addEventListener(ProgressEvent.PROGRESS,progressHandler);
  443.          param1.addEventListener(Event.COMPLETE,completeHandler);
  444.          param1.addEventListener(RSLEvent.RSL_PROGRESS,rslProgressHandler);
  445.          param1.addEventListener(RSLEvent.RSL_COMPLETE,rslCompleteHandler);
  446.          param1.addEventListener(RSLEvent.RSL_ERROR,rslErrorHandler);
  447.          param1.addEventListener(FlexEvent.INIT_PROGRESS,initProgressHandler);
  448.          param1.addEventListener(FlexEvent.INIT_COMPLETE,initCompleteHandler);
  449.       }
  450.       
  451.       public function get backgroundColor() : uint
  452.       {
  453.          return _backgroundColor;
  454.       }
  455.       
  456.       protected function set showPercentage(param1:Boolean) : void
  457.       {
  458.          _showPercentage = param1;
  459.          draw();
  460.       }
  461.       
  462.       override public function set visible(param1:Boolean) : void
  463.       {
  464.          if(!_visible && param1)
  465.          {
  466.             show();
  467.          }
  468.          else if(_visible && !param1)
  469.          {
  470.             hide();
  471.          }
  472.          _visible = param1;
  473.       }
  474.       
  475.       protected function get labelRect() : Rectangle
  476.       {
  477.          return new Rectangle(14,17,100,16);
  478.       }
  479.       
  480.       private function show() : void
  481.       {
  482.          _showingDisplay = true;
  483.          calcScale();
  484.          draw();
  485.          _displayTime = getTimer();
  486.       }
  487.       
  488.       protected function createChildren() : void
  489.       {
  490.          var _loc1_:Graphics = null;
  491.          var _loc2_:TextField = null;
  492.          var _loc3_:TextField = null;
  493.          var _loc4_:Graphics = null;
  494.          var _loc5_:Matrix = null;
  495.          var _loc6_:RectangularDropShadow = null;
  496.          _loc1_ = graphics;
  497.          if(backgroundImage != null)
  498.          {
  499.             loadBackgroundImage(backgroundImage);
  500.          }
  501.          _barFrameSprite = new Sprite();
  502.          _barSprite = new Sprite();
  503.          addChild(_barFrameSprite);
  504.          addChild(_barSprite);
  505.          _loc1_.beginFill(13421772,0.4);
  506.          _loc1_.drawRoundRect(calcX(_borderRect.x),calcY(_borderRect.y),_borderRect.width,_borderRect.height,_borderRect.cornerRadius * 2,_borderRect.cornerRadius * 2);
  507.          _loc1_.drawRoundRect(calcX(_borderRect.x + 1),calcY(_borderRect.y + 1),_borderRect.width - 2,_borderRect.height - 2,_borderRect.cornerRadius - 1 * 2,_borderRect.cornerRadius - 1 * 2);
  508.          _loc1_.endFill();
  509.          _loc1_.beginFill(13421772,0.4);
  510.          _loc1_.drawRoundRect(calcX(_borderRect.x + 1),calcY(_borderRect.y + 1),_borderRect.width - 2,_borderRect.height - 2,_borderRect.cornerRadius - 1 * 2,_borderRect.cornerRadius - 1 * 2);
  511.          _loc1_.endFill();
  512.          _loc4_ = _barFrameSprite.graphics;
  513.          _loc5_ = new Matrix();
  514.          _loc5_.createGradientBox(_barFrameRect.width,_barFrameRect.height,Math.PI / 2,calcX(_barFrameRect.x),calcY(_barFrameRect.y));
  515.          _loc4_.beginGradientFill(GradientType.LINEAR,[6054502,11909306],[1,1],[0,255],_loc5_);
  516.          _loc4_.drawRoundRect(calcX(_barFrameRect.x),calcY(_barFrameRect.y),_barFrameRect.width,_barFrameRect.height,_barFrameRect.cornerRadius * 2,_barFrameRect.cornerRadius * 2);
  517.          _loc4_.drawRoundRect(calcX(_barFrameRect.x + 1),calcY(_barFrameRect.y + 1),_barFrameRect.width - 2,_barFrameRect.height - 2,_barFrameRect.cornerRadius * 2,_barFrameRect.cornerRadius * 2);
  518.          _loc4_.endFill();
  519.          _labelObj = new TextField();
  520.          _labelObj.x = calcX(_labelRect.x);
  521.          _labelObj.y = calcY(_labelRect.y);
  522.          _labelObj.width = _labelRect.width;
  523.          _labelObj.height = _labelRect.height;
  524.          _labelObj.selectable = false;
  525.          _labelObj.defaultTextFormat = labelFormat;
  526.          addChild(_labelObj);
  527.          _percentObj = new TextField();
  528.          _percentObj.x = calcX(_percentRect.x);
  529.          _percentObj.y = calcY(_percentRect.y);
  530.          _percentObj.width = _percentRect.width;
  531.          _percentObj.height = _percentRect.height;
  532.          _percentObj.selectable = false;
  533.          _percentObj.defaultTextFormat = percentFormat;
  534.          addChild(_percentObj);
  535.          _loc6_ = new RectangularDropShadow();
  536.          _loc6_.color = 0;
  537.          _loc6_.angle = 90;
  538.          _loc6_.alpha = 0.6;
  539.          _loc6_.distance = 2;
  540.          _loc6_.tlRadius = _loc6_.trRadius = _loc6_.blRadius = _loc6_.brRadius = _borderRect.cornerRadius;
  541.          _loc6_.drawShadow(_loc1_,calcX(_borderRect.x),calcY(_borderRect.y),_borderRect.width,_borderRect.height);
  542.          _loc1_.lineStyle(1,16777215,0.3);
  543.          _loc1_.moveTo(calcX(_borderRect.x) + _borderRect.cornerRadius,calcY(_borderRect.y));
  544.          _loc1_.lineTo(calcX(_borderRect.x) - _borderRect.cornerRadius + _borderRect.width,calcY(_borderRect.y));
  545.       }
  546.       
  547.       private function loadBackgroundImage(param1:Object) : void
  548.       {
  549.          var cls:Class = null;
  550.          var newStyleObj:DisplayObject = null;
  551.          var loader:Loader = null;
  552.          var loaderContext:LoaderContext = null;
  553.          var classOrString:Object = param1;
  554.          if(Boolean(classOrString) && Boolean(classOrString as Class))
  555.          {
  556.             cls = Class(classOrString);
  557.             initBackgroundImage(new cls());
  558.          }
  559.          else if(Boolean(classOrString) && classOrString is String)
  560.          {
  561.             try
  562.             {
  563.                cls = Class(getDefinitionByName(String(classOrString)));
  564.             }
  565.             catch(e:Error)
  566.             {
  567.             }
  568.             if(cls)
  569.             {
  570.                newStyleObj = new cls();
  571.                initBackgroundImage(newStyleObj);
  572.             }
  573.             else
  574.             {
  575.                loader = new Loader();
  576.                loader.contentLoaderInfo.addEventListener(Event.COMPLETE,loader_completeHandler);
  577.                loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,loader_ioErrorHandler);
  578.                loaderContext = new LoaderContext();
  579.                loaderContext.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
  580.                loader.load(new URLRequest(String(classOrString)),loaderContext);
  581.             }
  582.          }
  583.       }
  584.       
  585.       private function hide() : void
  586.       {
  587.       }
  588.       
  589.       private function draw() : void
  590.       {
  591.          var _loc1_:Number = NaN;
  592.          if(_startedLoading)
  593.          {
  594.             if(!_startedInit)
  595.             {
  596.                _loc1_ = Math.round(getPercentLoaded(_value,_maximum) * DOWNLOAD_PERCENTAGE / 100);
  597.             }
  598.             else
  599.             {
  600.                _loc1_ = Math.round(getPercentLoaded(_value,_maximum) * (100 - DOWNLOAD_PERCENTAGE) / 100 + DOWNLOAD_PERCENTAGE);
  601.             }
  602.          }
  603.          else
  604.          {
  605.             _loc1_ = getPercentLoaded(_value,_maximum);
  606.          }
  607.          if(_labelObj)
  608.          {
  609.             _labelObj.text = _label;
  610.          }
  611.          if(_percentObj)
  612.          {
  613.             if(!_showPercentage)
  614.             {
  615.                _percentObj.visible = false;
  616.                _percentObj.text = "";
  617.             }
  618.             else
  619.             {
  620.                _percentObj.text = String(_loc1_) + "%";
  621.             }
  622.          }
  623.          if(Boolean(_barSprite) && Boolean(_barFrameSprite))
  624.          {
  625.             if(!_showProgressBar)
  626.             {
  627.                _barSprite.visible = false;
  628.                _barFrameSprite.visible = false;
  629.             }
  630.             else
  631.             {
  632.                drawProgressBar(_loc1_);
  633.             }
  634.          }
  635.       }
  636.       
  637.       protected function initProgressHandler(param1:Event) : void
  638.       {
  639.          var _loc2_:int = 0;
  640.          var _loc3_:Number = NaN;
  641.          _loc2_ = getTimer() - _startTime;
  642.          ++_initProgressCount;
  643.          if(!_showingDisplay && showDisplayForInit(_loc2_,_initProgressCount))
  644.          {
  645.             _displayStartCount = _initProgressCount;
  646.             show();
  647.          }
  648.          else if(_showingDisplay)
  649.          {
  650.             if(!_startedInit)
  651.             {
  652.                _startedInit = true;
  653.                label = initializingLabel;
  654.             }
  655.             _loc3_ = 100 * _initProgressCount / (_initProgressTotal - _displayStartCount);
  656.             setProgress(_loc3_,100);
  657.          }
  658.       }
  659.       
  660.       protected function get label() : String
  661.       {
  662.          return _label;
  663.       }
  664.       
  665.       protected function getPercentLoaded(param1:Number, param2:Number) : Number
  666.       {
  667.          var _loc3_:Number = NaN;
  668.          if(param1 == 0 || param2 == 0 || isNaN(param2) || isNaN(param1))
  669.          {
  670.             return 0;
  671.          }
  672.          _loc3_ = 100 * param1 / param2;
  673.          if(isNaN(_loc3_) || _loc3_ <= 0)
  674.          {
  675.             return 0;
  676.          }
  677.          if(_loc3_ > 99)
  678.          {
  679.             return 99;
  680.          }
  681.          return Math.round(_loc3_);
  682.       }
  683.       
  684.       protected function set downloadingLabel(param1:String) : void
  685.       {
  686.          _downloadingLabel = param1;
  687.       }
  688.       
  689.       public function get stageWidth() : Number
  690.       {
  691.          return _stageWidth;
  692.       }
  693.       
  694.       public function set stageHeight(param1:Number) : void
  695.       {
  696.          _stageHeight = param1;
  697.       }
  698.       
  699.       protected function get showPercentage() : Boolean
  700.       {
  701.          return _showPercentage;
  702.       }
  703.       
  704.       public function initialize() : void
  705.       {
  706.          _startTime = getTimer();
  707.          center(stageWidth,stageHeight);
  708.       }
  709.       
  710.       private function initBackgroundImage(param1:DisplayObject) : void
  711.       {
  712.          var _loc2_:Number = NaN;
  713.          var _loc3_:Number = NaN;
  714.          var _loc4_:Number = NaN;
  715.          var _loc5_:Number = NaN;
  716.          var _loc6_:Number = NaN;
  717.          var _loc7_:Number = NaN;
  718.          var _loc8_:Number = NaN;
  719.          var _loc9_:Number = NaN;
  720.          addChildAt(param1,0);
  721.          _loc2_ = param1.width;
  722.          _loc3_ = param1.height;
  723.          _loc4_ = calcBackgroundSize();
  724.          if(isNaN(_loc4_))
  725.          {
  726.             _loc7_ = 1;
  727.             _loc8_ = 1;
  728.          }
  729.          else
  730.          {
  731.             _loc9_ = _loc4_ * 0.01;
  732.             _loc7_ = _loc9_ * stageWidth / _loc2_;
  733.             _loc8_ = _loc9_ * stageHeight / _loc3_;
  734.          }
  735.          param1.scaleX = _loc7_;
  736.          param1.scaleY = _loc8_;
  737.          _loc5_ = Math.round(0.5 * (stageWidth - _loc2_ * _loc7_));
  738.          _loc6_ = Math.round(0.5 * (stageHeight - _loc3_ * _loc8_));
  739.          param1.x = _loc5_;
  740.          param1.y = _loc6_;
  741.          if(!isNaN(backgroundAlpha))
  742.          {
  743.             param1.alpha = backgroundAlpha;
  744.          }
  745.       }
  746.       
  747.       public function set backgroundImage(param1:Object) : void
  748.       {
  749.          _backgroundImage = param1;
  750.       }
  751.       
  752.       public function set backgroundAlpha(param1:Number) : void
  753.       {
  754.          _backgroundAlpha = param1;
  755.       }
  756.       
  757.       public function set backgroundColor(param1:uint) : void
  758.       {
  759.          _backgroundColor = param1;
  760.       }
  761.       
  762.       private function loader_completeHandler(param1:Event) : void
  763.       {
  764.          var _loc2_:DisplayObject = null;
  765.          _loc2_ = DisplayObject(LoaderInfo(param1.target).loader);
  766.          initBackgroundImage(_loc2_);
  767.       }
  768.       
  769.       public function get stageHeight() : Number
  770.       {
  771.          return _stageHeight;
  772.       }
  773.       
  774.       protected function get percentRect() : Rectangle
  775.       {
  776.          return new Rectangle(108,4,34,16);
  777.       }
  778.       
  779.       protected function completeHandler(param1:Event) : void
  780.       {
  781.       }
  782.       
  783.       protected function set label(param1:String) : void
  784.       {
  785.          if(!(param1 is Function))
  786.          {
  787.             _label = param1;
  788.          }
  789.          draw();
  790.       }
  791.       
  792.       protected function get showLabel() : Boolean
  793.       {
  794.          return _showLabel;
  795.       }
  796.    }
  797. }
  798.  
  799.